import { Router, Request, Response } from 'express'
import { AuthService } from '../services/authService'
import { authenticateToken, validateEmail, validatePhone, validatePassword, rateLimiter } from '../middleware/auth'

const router = Router()

// 邮箱密码注册
router.post('/register/email', rateLimiter(3, 15), async (req: Request, res: Response) => {
  try {
    const { email, password, username } = req.body
    
    // 参数验证
    if (!email || !password) {
      return res.status(400).json({
        error: 'MISSING_PARAMETERS',
        message: '邮箱和密码不能为空'
      })
    }
    
    // 邮箱格式验证
    if (!validateEmail(email)) {
      return res.status(400).json({
        error: 'INVALID_EMAIL',
        message: '邮箱格式不正确'
      })
    }
    
    // 密码强度验证
    const passwordValidation = validatePassword(password)
    if (!passwordValidation.valid) {
      return res.status(400).json({
        error: 'WEAK_PASSWORD',
        message: passwordValidation.message
      })
    }
    
    // 调用注册服务
    const result = await AuthService.registerWithEmail(email, password, username)
    
    if (result.success) {
      res.status(201).json({
        success: true,
        message: result.message,
        user: result.user,
        token: result.token,
        refresh_token: result.refresh_token
      })
    } else {
      res.status(400).json({
        success: false,
        error: result.error,
        message: result.message
      })
    }
    
  } catch (error) {
    console.error('邮箱注册路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 邮箱密码登录
router.post('/login/email', rateLimiter(5, 15), async (req: Request, res: Response) => {
  try {
    const { email, password } = req.body
    
    // 参数验证
    if (!email || !password) {
      return res.status(400).json({
        error: 'MISSING_PARAMETERS',
        message: '邮箱和密码不能为空'
      })
    }
    
    // 邮箱格式验证
    if (!validateEmail(email)) {
      return res.status(400).json({
        error: 'INVALID_EMAIL',
        message: '邮箱格式不正确'
      })
    }
    
    // 调用登录服务
    const result = await AuthService.loginWithEmail(email, password)
    
    if (result.success) {
      res.json({
        success: true,
        message: result.message,
        user: result.user,
        token: result.token,
        refresh_token: result.refresh_token
      })
    } else {
      res.status(401).json({
        success: false,
        error: result.error,
        message: result.message
      })
    }
    
  } catch (error) {
    console.error('邮箱登录路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 发送手机验证码
router.post('/send-code', rateLimiter(3, 1), async (req: Request, res: Response) => {
  try {
    const { phone, type = 'login' } = req.body
    
    // 参数验证
    if (!phone) {
      return res.status(400).json({
        error: 'MISSING_PARAMETERS',
        message: '手机号不能为空'
      })
    }
    
    // 手机号格式验证
    if (!validatePhone(phone)) {
      return res.status(400).json({
        error: 'INVALID_PHONE',
        message: '手机号格式不正确'
      })
    }
    
    // 类型验证
    if (!['login', 'register'].includes(type)) {
      return res.status(400).json({
        error: 'INVALID_TYPE',
        message: '无效的验证码类型'
      })
    }
    
    // 发送验证码
    const result = await AuthService.sendPhoneVerificationCode(phone, type)
    
    if (result.success) {
      res.json({
        success: true,
        message: result.message,
        code_id: result.code_id,
        // 开发环境返回验证码
        ...(process.env.NODE_ENV === 'development' && { dev_code: (result as any).dev_code })
      })
    } else {
      res.status(400).json({
        success: false,
        error: result.error,
        message: result.message
      })
    }
    
  } catch (error) {
    console.error('发送验证码路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 手机验证码登录/注册
router.post('/login/phone', rateLimiter(5, 15), async (req: Request, res: Response) => {
  try {
    const { phone, code, username } = req.body
    
    // 参数验证
    if (!phone || !code) {
      return res.status(400).json({
        error: 'MISSING_PARAMETERS',
        message: '手机号和验证码不能为空'
      })
    }
    
    // 手机号格式验证
    if (!validatePhone(phone)) {
      return res.status(400).json({
        error: 'INVALID_PHONE',
        message: '手机号格式不正确'
      })
    }
    
    // 验证码格式验证
    if (!/^\d{6}$/.test(code)) {
      return res.status(400).json({
        error: 'INVALID_CODE',
        message: '验证码格式不正确'
      })
    }
    
    // 调用登录服务
    const result = await AuthService.loginWithPhone(phone, code, username)
    
    if (result.success) {
      res.json({
        success: true,
        message: result.message,
        user: result.user,
        token: result.token,
        refresh_token: result.refresh_token
      })
    } else {
      res.status(401).json({
        success: false,
        error: result.error,
        message: result.message
      })
    }
    
  } catch (error) {
    console.error('手机登录路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 获取用户信息
router.get('/me', authenticateToken, async (req: Request, res: Response) => {
  try {
    res.json({
      success: true,
      user: req.user
    })
  } catch (error) {
    console.error('获取用户信息路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 登出
router.post('/logout', authenticateToken, async (req: Request, res: Response) => {
  try {
    const token = req.headers.authorization?.split(' ')[1]
    
    if (token) {
      await AuthService.logout(token)
    }
    
    res.json({
      success: true,
      message: '登出成功'
    })
  } catch (error) {
    console.error('登出路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

// 刷新令牌
router.post('/refresh', async (req: Request, res: Response) => {
  try {
    const { refresh_token } = req.body
    
    if (!refresh_token) {
      return res.status(400).json({
        error: 'MISSING_REFRESH_TOKEN',
        message: '刷新令牌不能为空'
      })
    }
    
    // TODO: 实现刷新令牌逻辑
    res.status(501).json({
      error: 'NOT_IMPLEMENTED',
      message: '刷新令牌功能尚未实现'
    })
    
  } catch (error) {
    console.error('刷新令牌路由错误:', error)
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: '服务器内部错误'
    })
  }
})

export { router as authRoutes }
